/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package wggcth.persistencia.controle;

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import wggcth.persistencia.controle.exceptions.IllegalOrphanException;
import wggcth.persistencia.controle.exceptions.NonexistentEntityException;
import wggcth.persistencia.vo.Amostra;
import wggcth.persistencia.vo.Experimento;
import wggcth.persistencia.vo.DadosExperimento;
import java.util.ArrayList;
import java.util.Collection;

/**
 *
 * @author deusemar
 */
public class AmostraJpaController {

    public AmostraJpaController() {
        emf = Persistence.createEntityManagerFactory("wggcthPU");
    }
    private EntityManagerFactory emf = null;

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }

    public void create(Amostra amostra) {
        if (amostra.getDadosExperimentoCollection() == null) {
            amostra.setDadosExperimentoCollection(new ArrayList<DadosExperimento>());
        }
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Experimento idexperimento = amostra.getIdexperimento();
            if (idexperimento != null) {
                idexperimento = em.getReference(idexperimento.getClass(), idexperimento.getIdexperimento());
                amostra.setIdexperimento(idexperimento);
            }
            Collection<DadosExperimento> attachedDadosExperimentoCollection = new ArrayList<DadosExperimento>();
            for (DadosExperimento dadosExperimentoCollectionDadosExperimentoToAttach : amostra.getDadosExperimentoCollection()) {
                dadosExperimentoCollectionDadosExperimentoToAttach = em.getReference(dadosExperimentoCollectionDadosExperimentoToAttach.getClass(), dadosExperimentoCollectionDadosExperimentoToAttach.getDadosExperimentoPK());
                attachedDadosExperimentoCollection.add(dadosExperimentoCollectionDadosExperimentoToAttach);
            }
            amostra.setDadosExperimentoCollection(attachedDadosExperimentoCollection);
            em.persist(amostra);
            if (idexperimento != null) {
                idexperimento.getAmostraCollection().add(amostra);
                idexperimento = em.merge(idexperimento);
            }
            for (DadosExperimento dadosExperimentoCollectionDadosExperimento : amostra.getDadosExperimentoCollection()) {
                Amostra oldAmostraOfDadosExperimentoCollectionDadosExperimento = dadosExperimentoCollectionDadosExperimento.getAmostra();
                dadosExperimentoCollectionDadosExperimento.setAmostra(amostra);
                dadosExperimentoCollectionDadosExperimento = em.merge(dadosExperimentoCollectionDadosExperimento);
                if (oldAmostraOfDadosExperimentoCollectionDadosExperimento != null) {
                    oldAmostraOfDadosExperimentoCollectionDadosExperimento.getDadosExperimentoCollection().remove(dadosExperimentoCollectionDadosExperimento);
                    oldAmostraOfDadosExperimentoCollectionDadosExperimento = em.merge(oldAmostraOfDadosExperimentoCollectionDadosExperimento);
                }
            }
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(Amostra amostra) throws IllegalOrphanException, NonexistentEntityException, Exception {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Amostra persistentAmostra = em.find(Amostra.class, amostra.getIdamostra());
            Experimento idexperimentoOld = persistentAmostra.getIdexperimento();
            Experimento idexperimentoNew = amostra.getIdexperimento();
            Collection<DadosExperimento> dadosExperimentoCollectionOld = persistentAmostra.getDadosExperimentoCollection();
            Collection<DadosExperimento> dadosExperimentoCollectionNew = amostra.getDadosExperimentoCollection();
            List<String> illegalOrphanMessages = null;
            for (DadosExperimento dadosExperimentoCollectionOldDadosExperimento : dadosExperimentoCollectionOld) {
                if (!dadosExperimentoCollectionNew.contains(dadosExperimentoCollectionOldDadosExperimento)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain DadosExperimento " + dadosExperimentoCollectionOldDadosExperimento + " since its amostra field is not nullable.");
                }
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            if (idexperimentoNew != null) {
                idexperimentoNew = em.getReference(idexperimentoNew.getClass(), idexperimentoNew.getIdexperimento());
                amostra.setIdexperimento(idexperimentoNew);
            }
            Collection<DadosExperimento> attachedDadosExperimentoCollectionNew = new ArrayList<DadosExperimento>();
            for (DadosExperimento dadosExperimentoCollectionNewDadosExperimentoToAttach : dadosExperimentoCollectionNew) {
                dadosExperimentoCollectionNewDadosExperimentoToAttach = em.getReference(dadosExperimentoCollectionNewDadosExperimentoToAttach.getClass(), dadosExperimentoCollectionNewDadosExperimentoToAttach.getDadosExperimentoPK());
                attachedDadosExperimentoCollectionNew.add(dadosExperimentoCollectionNewDadosExperimentoToAttach);
            }
            dadosExperimentoCollectionNew = attachedDadosExperimentoCollectionNew;
            amostra.setDadosExperimentoCollection(dadosExperimentoCollectionNew);
            amostra = em.merge(amostra);
            if (idexperimentoOld != null && !idexperimentoOld.equals(idexperimentoNew)) {
                idexperimentoOld.getAmostraCollection().remove(amostra);
                idexperimentoOld = em.merge(idexperimentoOld);
            }
            if (idexperimentoNew != null && !idexperimentoNew.equals(idexperimentoOld)) {
                idexperimentoNew.getAmostraCollection().add(amostra);
                idexperimentoNew = em.merge(idexperimentoNew);
            }
            for (DadosExperimento dadosExperimentoCollectionNewDadosExperimento : dadosExperimentoCollectionNew) {
                if (!dadosExperimentoCollectionOld.contains(dadosExperimentoCollectionNewDadosExperimento)) {
                    Amostra oldAmostraOfDadosExperimentoCollectionNewDadosExperimento = dadosExperimentoCollectionNewDadosExperimento.getAmostra();
                    dadosExperimentoCollectionNewDadosExperimento.setAmostra(amostra);
                    dadosExperimentoCollectionNewDadosExperimento = em.merge(dadosExperimentoCollectionNewDadosExperimento);
                    if (oldAmostraOfDadosExperimentoCollectionNewDadosExperimento != null && !oldAmostraOfDadosExperimentoCollectionNewDadosExperimento.equals(amostra)) {
                        oldAmostraOfDadosExperimentoCollectionNewDadosExperimento.getDadosExperimentoCollection().remove(dadosExperimentoCollectionNewDadosExperimento);
                        oldAmostraOfDadosExperimentoCollectionNewDadosExperimento = em.merge(oldAmostraOfDadosExperimentoCollectionNewDadosExperimento);
                    }
                }
            }
            em.getTransaction().commit();
        } catch (Exception ex) {
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                Integer id = amostra.getIdamostra();
                if (findAmostra(id) == null) {
                    throw new NonexistentEntityException("The amostra with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException {
        EntityManager em = null;
        try {
            em = getEntityManager();
            em.getTransaction().begin();
            Amostra amostra;
            try {
                amostra = em.getReference(Amostra.class, id);
                amostra.getIdamostra();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The amostra with id " + id + " no longer exists.", enfe);
            }
            List<String> illegalOrphanMessages = null;
            Collection<DadosExperimento> dadosExperimentoCollectionOrphanCheck = amostra.getDadosExperimentoCollection();
            for (DadosExperimento dadosExperimentoCollectionOrphanCheckDadosExperimento : dadosExperimentoCollectionOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Amostra (" + amostra + ") cannot be destroyed since the DadosExperimento " + dadosExperimentoCollectionOrphanCheckDadosExperimento + " in its dadosExperimentoCollection field has a non-nullable amostra field.");
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            Experimento idexperimento = amostra.getIdexperimento();
            if (idexperimento != null) {
                idexperimento.getAmostraCollection().remove(amostra);
                idexperimento = em.merge(idexperimento);
            }
            em.remove(amostra);
            em.getTransaction().commit();
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<Amostra> findAmostraEntities() {
        return findAmostraEntities(true, -1, -1);
    }

    public List<Amostra> findAmostraEntities(int maxResults, int firstResult) {
        return findAmostraEntities(false, maxResults, firstResult);
    }

    private List<Amostra> findAmostraEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            Query q = em.createQuery("select object(o) from Amostra as o");
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public Amostra findAmostra(Integer id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(Amostra.class, id);
        } finally {
            em.close();
        }
    }

    public int getAmostraCount() {
        EntityManager em = getEntityManager();
        try {
            return ((Long) em.createQuery("select count(o) from Amostra as o").getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }

}
